Object Oriented Programming Languages (OOPL) and Relational Database Management Systems (RDMS) are the two major technological components of most of the contemporary computer programs. An OOPL encodes the domain knowledge (the logic layer) and visualization (the presentation layer) of the application. A database persistently stores application data and provides a declarative query language to selectively retrieve application data when needed.
The existence of two distinct technologies (OOPL and RDMS) leads to an impedance mismatch that must be resolved in the interface layer between the logic layer and the database. Layered architectures try to minimize and contain the impact of two distinct technologies on the design, development, and maintenance of applications.
Multiple approaches were proposed to merge the two different paradigms of computing: object oriented and relational database technologies. Primary motivations were: the elimination of the impedance mismatch between the persistence and logic layers, persistent storage and query of complex objects, and a single computing framework
These attempts led to competing proposals and standards. The object oriented community responded with extensions to object oriented technologies while the relational database community proposed extensions to relational databases. Two major proposals are, therefore, object databases and object relational databases
Object databases extend the object oriented paradigm to incorporate the concept of relation. In contrast, object relational databases extend the relational data model by providing support for complex data types. In either case, the goal is to provide a single platform that provides persistence and ad hoc query of complex objects.
The logic layer typically consists of rules. It has been anticipated for decades that rules stored and managed in a rule engine or knowledgebase would revolutionize the software industry. Given the fact that relational data model is firmly founded on logic, one might expect that the (object) relational databases should include rules. Although some proposals require the rules as essential, there is not a consensus on whether they are an essential or required as part of next generation systems.
Expert systems explicitly support rules and a significant number of object oriented concepts. Although expert systems are well known, they are not widely adopted by the mainstream software designers and developers. Common characteristics of expert systems (shells) are: a declarative rule language, a declarative language support for object oriented concepts, a pattern matching algorithm (typically a variant of the RETE algorithm), and host language support, for example Java or C++.
Rule engines have several major drawbacks. First, rule engines contain concepts and syntax that are alien to object oriented programming languages and relational databases. Second, rule engines include a fixed pattern-matching algorithm, which may not perform or scale to complex problems. Third, rule engines need to be integrated into object oriented programming languages and relational databases. Fourth, rule engines lack standards for defining, packaging, sharing, and integrating knowledge from different sources. Finally, rule engines are not extensible or adaptable to the particular needs of an application, i.e., they are a fixed generic solution.
Despite the strong need for isolating the logic layer and contrary to the long anticipation, widespread adaptation of rule engines to object oriented software applications did not materialize.
Intelligent databases, i.e., active and deductive databases, are proposals to extend databases to include the rule and event support. Most commercial databases do not yet include explicit rule support that is capable of representing and executing rules in the database. These proposals do not address the impedance mismatch, which is likely to become even more severe if logic layer is moved to persistence layer. The closest database feature, databases triggers, does not meet the needs of business rules.
What is needed to solve these problems is a single computing environment that seamlessly integrates object oriented programming, rules, and relations of complex objects.